home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / tcp_ip / tnos / tnos100s / gps.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-27  |  7.9 KB  |  404 lines

  1. /* GPS port-related user commands
  2.  *   (c) 1993 Brian A. Lantz
  3.  */
  4. #include <stdio.h>
  5. #include "global.h"
  6. #include "mbuf.h"
  7. #include "proc.h"
  8. #include "netuser.h"
  9. #include "internet.h"
  10. #include "cmdparse.h"
  11. #include "timer.h"
  12. #include "iface.h"
  13. #include "udp.h"
  14. #ifndef UNIX
  15. #include "i8250.h"
  16. #endif
  17. #include "asy.h"
  18. #include "socket.h"
  19. #include "usock.h"
  20. #include "commands.h"
  21. #include "gps.h"
  22. #include "config.h"
  23. #ifdef ITT
  24. #include "imp.h"
  25. IMP *BARBase = 0;
  26. #endif
  27.  
  28. #undef GPSDIAG 1
  29.  
  30. static short GPStype = 0;
  31. struct iface *GPSactive;
  32. static struct proc *GPSproc;
  33. static int dev;
  34. static char incoming[1024];
  35. static char fullbuf[GPSMAXLEN];
  36. static char *CmdStr, *InitStr, *TermStr;
  37. #ifdef notyet
  38. static char *TimeStr;
  39. #endif
  40.  
  41. #ifdef GPSDIAG
  42. pprintf (str, arg)
  43. char *str;
  44. char *arg;
  45. {
  46.     printf (str, arg);
  47.     fflush(stdout);
  48. }
  49. #endif
  50.  
  51. unsigned char MAG[] = { 0,0,0 };
  52.  
  53. static gpstype Gtypes[] = {
  54.     { "Standard", 0, (unsigned char *) 0    },
  55.     { "Magellan", 0, MAG            },
  56.     { (char *) 0, 0, (unsigned char *) 0    }
  57. };
  58.  
  59.  
  60. void
  61. GPSrawsend (str, len)
  62. unsigned char *str;
  63. int len;
  64. {
  65. struct mbuf *bp;
  66.  
  67. #ifdef GPSDIAG
  68.     pprintf("GPSrawsend() reached\n");
  69. #endif
  70.     if (!len)
  71.         return;
  72.     asy_send (dev, qdata (str, len));
  73. }
  74.  
  75.  
  76. char *
  77. GPSgetstr ()
  78. {
  79. char *cp;
  80. int c;
  81.     
  82.     cp = incoming;
  83.     memset (incoming, 0x20, 1024);
  84.     while((c = get_asy(dev)) != -1){
  85.         *cp++ = ((c == '\n') || (c == '\l')) ? ' ' : c;
  86.         if (c == '\l')
  87.             break;
  88.     }
  89.     *cp = 0;
  90.     return (strdup (incoming));
  91. }
  92.  
  93.  
  94. char *
  95. GPSsendstr (str)
  96. char *str;
  97. {
  98. char buf[256];
  99. int response = 1;
  100.  
  101. #ifdef GPSDIAG
  102.     pprintf("GPSsendstr() reached\n");
  103. #endif
  104. #ifdef nope
  105.     return (strdup(""));
  106. #else
  107.     if ((GPSactive == NULLIF) || !str || !strlen (str))
  108.         return (strdup (""));
  109.     if (*str == '-')    {
  110.         response = 0;
  111.         str++;
  112.     }
  113.     sprintf (buf, "%s\n\l", str);
  114.     GPSrawsend ((unsigned char *)buf, strlen (buf));
  115.     if (!response)
  116.         return (strdup (""));
  117.     return (GPSgetstr());
  118. #endif
  119. }
  120.  
  121.  
  122. /* Start GPS on serial line */
  123. int
  124. GPSstart(argc,argv,p)
  125. int argc;
  126. char *argv[];
  127. void *p;
  128. {
  129. register struct iface *ifp;
  130. register struct asy *ap;
  131. char *response, *cp;
  132. int (*rawsave)();
  133.  
  134.     if((ifp = if_lookup(argv[1])) == NULLIF){
  135.         tprintf(Badinterface,argv[1]);
  136.         return 1;
  137.     }
  138.     for(dev=0,ap = Asy;dev < ASY_MAX;dev++,ap++)
  139.         if(ap->iface == ifp)
  140.             break;
  141.     if(dev == ASY_MAX){
  142.         tprintf("Interface %s not asy port\n",argv[1]);
  143.         return 1;
  144.     }
  145.     if (GPSactive != NULLIF)    {
  146.         tprintf("GPS session already active on %s\n",GPSactive->name);
  147.         return 1;
  148.     }
  149.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  150.     chname(Curproc,"GPS tip");
  151.     GPSactive = ifp;
  152.     GPSproc = Curproc;
  153.     tprintf("GPS started on %s\n",argv[1]);
  154.  
  155.     /* Save output handler and temporarily redirect output to null */
  156.     rawsave = ifp->raw;
  157.     ifp->raw = bitbucket;
  158.     /* Suspend packet input drivers */
  159.     suspend(ifp->rxproc);
  160.     GPSrawsend (Gtypes[GPStype].data, Gtypes[GPStype].len);
  161.     free (GPSsendstr (InitStr));
  162. #ifdef GPSDIAG
  163.         pprintf("GPScmd reached\n");
  164. #endif
  165. #ifdef GPSDIAG
  166.         pprintf("GPS initialization complete\n");
  167. #endif
  168.  
  169.     for(;;) {
  170.         response = GPSgetstr ();
  171. #ifdef GPSDIAG
  172.         pprintf("GPSgetstr response - '%s'\n",response);
  173. #endif
  174.         {
  175.         FILE *fp;
  176.             strcpy (fullbuf, Hostname);
  177.             cp = strchr (fullbuf, '.');
  178.             if (cp)
  179.                 *cp = 0;
  180.             strcat (fullbuf, ": ");
  181.             strcat (fullbuf, response);
  182.             free (response);
  183.             if (CurrentPos)
  184.                 free (CurrentPos);
  185.             CurrentPos = strdup (fullbuf);
  186.             fp = fopen (GPSfile, "a+");    /* no error checking yet */
  187.             rewind (fp);
  188.             fwrite (fullbuf, 1, GPSMAXLEN, fp);
  189.             fclose (fp);
  190.         }
  191.     }
  192. #ifdef GPSDIAG
  193.     pprintf("GPS shutting down\n");
  194. #endif
  195.     free (GPSsendstr (TermStr));
  196.     GPSactive = NULLIF;
  197.     ifp->raw = rawsave;
  198.     resume(ifp->rxproc);
  199.     return 0;
  200. }
  201.  
  202. int
  203. GPSstop(argc,argv,p)
  204. int argc;
  205. char *argv[];
  206. void *p;
  207. {
  208. struct iface *ifp;
  209.  
  210.     if((ifp = if_lookup(argv[1])) == NULLIF){
  211.         tprintf(Badinterface,argv[1]);
  212.         return 1;
  213.     }
  214.     if ((GPSactive == NULLIF) || GPSactive != ifp)    {
  215.         tprintf ("There is no GPS active on %s!\n", argv[1]);
  216.         return 1;     /* wasn't active anyway */
  217.     }
  218.     alert (GPSproc, -1);
  219.     return 0;
  220. }
  221.  
  222.  
  223. static int
  224. dostr(argc,argv,label,description,str)
  225. int argc;
  226. char *argv[];
  227. char *label, *description, **str;
  228. {
  229.     if(argc > 2) {
  230.             tprintf ("Usage: gps %s \"<gps command string>\"\n", label);
  231.         return 0;
  232.     }
  233.  
  234.     if(argc < 2) {
  235.         if(*str != NULLCHAR)
  236.             tprintf("%s: %s", description, *str);
  237.     }
  238.     else {
  239.         if(*str != NULLCHAR){
  240.             free(*str);
  241.             *str = NULLCHAR;    /* reset the pointer */
  242.         }
  243.         if(!strlen(argv[1]))
  244.             return 0;        /* clearing the buffer */
  245.         *str = mallocw(strlen(argv[1])+5);/* allow for the EOL char */
  246.         strcpy(*str, argv[1]);
  247.         strcat(*str, "\n");        /* add the EOL char */
  248.     }
  249.     return 0;
  250. }
  251.  
  252. static int docmdstring __ARGS((int argc,char *argv[],void *p)); 
  253. static int doinitstring __ARGS((int argc,char *argv[],void *p)); 
  254. static int dosendstring __ARGS((int argc,char *argv[],void *p)); 
  255. static int dosetstring __ARGS((int argc,char *argv[],void *p)); 
  256. static int dotermstring __ARGS((int argc,char *argv[],void *p));
  257. static int dotype __ARGS((int argc,char *argv[],void *p));
  258. #ifdef notyet
  259. static int dotimestring __ARGS((int argc,char *argv[],void *p)); 
  260. #endif
  261.  
  262. static struct cmds GPScmds[] = {
  263.     "cmdstring",    docmdstring,    0,    0,    NULLCHAR,
  264.     "initstring",    doinitstring,    0,    0,    NULLCHAR,
  265.     "sendstring",    dosendstring,    0,    0,    NULLCHAR,
  266. #ifdef GPSDIAG
  267.     "setstring",    dosetstring,    0,    0,    NULLCHAR,
  268. #endif
  269.     "termstring",    dotermstring,    0,    0,    NULLCHAR,
  270. #ifdef notyet
  271.     "timestring",    dotimestring,    0,    0,    NULLCHAR,
  272. #endif
  273.     "type",        dotype,        0,    0,    NULLCHAR,
  274.     NULLCHAR,
  275. };
  276.  
  277. int
  278. dogps(argc,argv,p)
  279. int argc;
  280. char *argv[];
  281. void *p;
  282. {
  283.     return subcmd(GPScmds,argc,argv,p);
  284. }
  285.  
  286.  
  287. static int
  288. dotype(argc,argv,p)
  289. int argc;
  290. char *argv[];
  291. void *p;
  292. {
  293.     return setshort (&GPStype, "GPS manufacturer type:",argc, argv);
  294. }
  295.  
  296.  
  297. static int
  298. docmdstring(argc,argv,p)
  299. int argc;
  300. char *argv[];
  301. void *p;
  302. {
  303.     return dostr (argc, argv, "cmdstring", "GPS Position Command String", &CmdStr);
  304. }
  305.  
  306. static int
  307. doinitstring(argc,argv,p)
  308. int argc;
  309. char *argv[];
  310. void *p;
  311. {
  312.     return dostr (argc, argv, "initstring", "GPS Initialization String", &InitStr);
  313. }
  314.  
  315. #ifdef GPSDIAG
  316. static int
  317. dosetstring(argc,argv,p)
  318. int argc;
  319. char *argv[];
  320. void *p;
  321. {
  322.     return dostr (argc, argv, "setstring", "Current GPS data string", &CurrentPos);
  323. }
  324. #endif
  325.  
  326. static int
  327. dotermstring(argc,argv,p)
  328. int argc;
  329. char *argv[];
  330. void *p;
  331. {
  332.     return dostr (argc, argv, "termstring", "GPS Termination String", &TermStr);
  333. }
  334.  
  335. #ifdef notyet
  336. static int
  337. dotimestring(argc,argv,p)
  338. int argc;
  339. char *argv[];
  340. void *p;
  341. {
  342.     return dostr (argc, argv, "timestring", "GPS Time String", &TimeStr);
  343. }
  344. #endif
  345.  
  346. static int
  347. dosendstring(argc,argv,p)
  348. int argc;
  349. char *argv[];
  350. void *p;
  351. {
  352. char *response;
  353.  
  354.     response = GPSsendstr (argv[1]);
  355.     if (*response)
  356.         tprintf ("GPS Response: %s\n", response);
  357.     free (response);
  358.     return 0;
  359. }
  360.  
  361. #ifdef ITT
  362. /*************************************************************
  363.        Hardware daemon routines specific to ITT
  364.  ************************************************************/
  365. #define READ_DATA    (*((short *)0x700828))
  366.  
  367.  
  368. /* These are called from the timer process on every tick. NOTE! These
  369.  * functions can NOT be called at interrupt time because they call the OS
  370.  */
  371. void
  372. panictick()
  373. {
  374. static short itwas = 1;        /* last state of panic button */
  375. short itis;
  376.  
  377.     itis = READ_DATA & 0xfbff;
  378.     if (itwas && !itis)    /* high to low transition */
  379.         POStick (NULL);
  380.     itwas = itis;
  381. }
  382.  
  383. void
  384. gpstick()
  385. {
  386. int ttl = 0, on_off = 2;    /* offset from Set register to Reset reg */
  387. unsigned char *duart = (unsigned char *) 0xec0000;
  388.  
  389.         /* assert TTL_ON if no RS232_ON */
  390.     if(!(READ_DATA & 0xfdff))
  391.         ttl = 2;
  392.     duart[0x1d + ttl] = 2;
  393.     
  394. #ifdef nope
  395.     /* assert GPSON_OFF if gps code is running */
  396.     if (GPSactive == NULLIF)
  397.         on_off = 0;
  398.     duart[0x1d + on_off] = 0x80;
  399. #endif
  400. }
  401.  
  402.  
  403. #endif
  404.